home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Leser 19 / Amiga Plus Leser CD 19.iso / Tools / MorphOS / cvs-1.11.2 / source / amiga / netinclude / inline / bsdsocket.h
Encoding:
C/C++ Source or Header  |  2002-11-18  |  74.6 KB  |  1,857 lines
  1. #ifndef _INLINE_BSDSOCKET_H
  2. #define _INLINE_BSDSOCKET_H
  3.  
  4. #ifndef  EXEC_LISTS_H
  5. #include <exec/lists.h>
  6. #endif
  7. #ifndef  DEVICES_TIMER_H
  8. #include <devices/timer.h>
  9. #endif
  10. #ifndef  UTILITY_TAGITEM_H
  11. #include <utility/tagitem.h>
  12. #endif
  13. #ifndef  UTILITY_HOOKS_H
  14. #include <utility/hooks.h>
  15. #endif
  16. #ifndef  NETINET_IN_H
  17. #include <netinet/in.h>
  18. #endif
  19. #ifndef  SYS_TYPES_H
  20. #include <sys/types.h>
  21. #endif
  22. #ifndef  SYS_SOCKET_H
  23. #include <sys/socket.h>
  24. #endif
  25. #ifndef  SYS_MBUF_H
  26. #include <sys/mbuf.h>
  27. #endif
  28. #ifndef  NET_ROUTE_H
  29. #include <net/route.h>
  30. #endif
  31. #ifndef  NETDB_H
  32. #include <netdb.h>
  33. #endif
  34. #ifndef  LIBRARIES_BSDSOCKET_H
  35. #include <libraries/bsdsocket.h>
  36. #endif
  37. #ifndef  DOS_DOSEXTENS_H
  38. #include <dos/dosextens.h>
  39. #endif
  40.  
  41. #ifndef BSDSOCKET_BASE_NAME
  42. #define BSDSOCKET_BASE_NAME SocketBase
  43. #endif
  44.  
  45. #define socket(domain, type, protocol) ({ \
  46.   LONG _socket_domain = (domain); \
  47.   LONG _socket_type = (type); \
  48.   LONG _socket_protocol = (protocol); \
  49.   LONG _socket__re = \
  50.   ({ \
  51.   register struct Library * const __socket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  52.   register LONG __socket__re __asm("d0"); \
  53.   register LONG __socket_domain __asm("d0") = (_socket_domain); \
  54.   register LONG __socket_type __asm("d1") = (_socket_type); \
  55.   register LONG __socket_protocol __asm("d2") = (_socket_protocol); \
  56.   __asm volatile ("jsr a6@(-30:W)" \
  57.   : "=r"(__socket__re) \
  58.   : "r"(__socket__bn), "r"(__socket_domain), "r"(__socket_type), "r"(__socket_protocol)  \
  59.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  60.   __socket__re; \
  61.   }); \
  62.   _socket__re; \
  63. })
  64.  
  65. #define bind(sock, name, namelen) ({ \
  66.   LONG _bind_sock = (sock); \
  67.   struct sockaddr * _bind_name = (name); \
  68.   LONG _bind_namelen = (namelen); \
  69.   LONG _bind__re = \
  70.   ({ \
  71.   register struct Library * const __bind__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  72.   register LONG __bind__re __asm("d0"); \
  73.   register LONG __bind_sock __asm("d0") = (_bind_sock); \
  74.   register struct sockaddr * __bind_name __asm("a0") = (_bind_name); \
  75.   register LONG __bind_namelen __asm("d1") = (_bind_namelen); \
  76.   __asm volatile ("jsr a6@(-36:W)" \
  77.   : "=r"(__bind__re) \
  78.   : "r"(__bind__bn), "r"(__bind_sock), "r"(__bind_name), "r"(__bind_namelen)  \
  79.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  80.   __bind__re; \
  81.   }); \
  82.   _bind__re; \
  83. })
  84.  
  85. #define listen(sock, backlog) ({ \
  86.   LONG _listen_sock = (sock); \
  87.   LONG _listen_backlog = (backlog); \
  88.   LONG _listen__re = \
  89.   ({ \
  90.   register struct Library * const __listen__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  91.   register LONG __listen__re __asm("d0"); \
  92.   register LONG __listen_sock __asm("d0") = (_listen_sock); \
  93.   register LONG __listen_backlog __asm("d1") = (_listen_backlog); \
  94.   __asm volatile ("jsr a6@(-42:W)" \
  95.   : "=r"(__listen__re) \
  96.   : "r"(__listen__bn), "r"(__listen_sock), "r"(__listen_backlog)  \
  97.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  98.   __listen__re; \
  99.   }); \
  100.   _listen__re; \
  101. })
  102.  
  103. #define accept(sock, addr, addrlen) ({ \
  104.   LONG _accept_sock = (sock); \
  105.   struct sockaddr * _accept_addr = (addr); \
  106.   LONG * _accept_addrlen = (addrlen); \
  107.   LONG _accept__re = \
  108.   ({ \
  109.   register struct Library * const __accept__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  110.   register LONG __accept__re __asm("d0"); \
  111.   register LONG __accept_sock __asm("d0") = (_accept_sock); \
  112.   register struct sockaddr * __accept_addr __asm("a0") = (_accept_addr); \
  113.   register LONG * __accept_addrlen __asm("a1") = (_accept_addrlen); \
  114.   __asm volatile ("jsr a6@(-48:W)" \
  115.   : "=r"(__accept__re) \
  116.   : "r"(__accept__bn), "r"(__accept_sock), "r"(__accept_addr), "r"(__accept_addrlen)  \
  117.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  118.   __accept__re; \
  119.   }); \
  120.   _accept__re; \
  121. })
  122.  
  123. #define connect(sock, name, namelen) ({ \
  124.   LONG _connect_sock = (sock); \
  125.   struct sockaddr * _connect_name = (name); \
  126.   LONG _connect_namelen = (namelen); \
  127.   LONG _connect__re = \
  128.   ({ \
  129.   register struct Library * const __connect__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  130.   register LONG __connect__re __asm("d0"); \
  131.   register LONG __connect_sock __asm("d0") = (_connect_sock); \
  132.   register struct sockaddr * __connect_name __asm("a0") = (_connect_name); \
  133.   register LONG __connect_namelen __asm("d1") = (_connect_namelen); \
  134.   __asm volatile ("jsr a6@(-54:W)" \
  135.   : "=r"(__connect__re) \
  136.   : "r"(__connect__bn), "r"(__connect_sock), "r"(__connect_name), "r"(__connect_namelen)  \
  137.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  138.   __connect__re; \
  139.   }); \
  140.   _connect__re; \
  141. })
  142.  
  143. #define sendto(sock, buf, len, flags, to, tolen) ({ \
  144.   LONG _sendto_sock = (sock); \
  145.   APTR _sendto_buf = (buf); \
  146.   LONG _sendto_len = (len); \
  147.   LONG _sendto_flags = (flags); \
  148.   struct sockaddr * _sendto_to = (to); \
  149.   LONG _sendto_tolen = (tolen); \
  150.   LONG _sendto__re = \
  151.   ({ \
  152.   register struct Library * const __sendto__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  153.   register LONG __sendto__re __asm("d0"); \
  154.   register LONG __sendto_sock __asm("d0") = (_sendto_sock); \
  155.   register APTR __sendto_buf __asm("a0") = (_sendto_buf); \
  156.   register LONG __sendto_len __asm("d1") = (_sendto_len); \
  157.   register LONG __sendto_flags __asm("d2") = (_sendto_flags); \
  158.   register struct sockaddr * __sendto_to __asm("a1") = (_sendto_to); \
  159.   register LONG __sendto_tolen __asm("d3") = (_sendto_tolen); \
  160.   __asm volatile ("jsr a6@(-60:W)" \
  161.   : "=r"(__sendto__re) \
  162.   : "r"(__sendto__bn), "r"(__sendto_sock), "r"(__sendto_buf), "r"(__sendto_len), "r"(__sendto_flags), "r"(__sendto_to), "r"(__sendto_tolen)  \
  163.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  164.   __sendto__re; \
  165.   }); \
  166.   _sendto__re; \
  167. })
  168.  
  169. #define send(sock, buf, len, flags) ({ \
  170.   LONG _send_sock = (sock); \
  171.   APTR _send_buf = (buf); \
  172.   LONG _send_len = (len); \
  173.   LONG _send_flags = (flags); \
  174.   LONG _send__re = \
  175.   ({ \
  176.   register struct Library * const __send__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  177.   register LONG __send__re __asm("d0"); \
  178.   register LONG __send_sock __asm("d0") = (_send_sock); \
  179.   register APTR __send_buf __asm("a0") = (_send_buf); \
  180.   register LONG __send_len __asm("d1") = (_send_len); \
  181.   register LONG __send_flags __asm("d2") = (_send_flags); \
  182.   __asm volatile ("jsr a6@(-66:W)" \
  183.   : "=r"(__send__re) \
  184.   : "r"(__send__bn), "r"(__send_sock), "r"(__send_buf), "r"(__send_len), "r"(__send_flags)  \
  185.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  186.   __send__re; \
  187.   }); \
  188.   _send__re; \
  189. })
  190.  
  191. #define recvfrom(sock, buf, len, flags, addr, addrlen) ({ \
  192.   LONG _recvfrom_sock = (sock); \
  193.   APTR _recvfrom_buf = (buf); \
  194.   LONG _recvfrom_len = (len); \
  195.   LONG _recvfrom_flags = (flags); \
  196.   struct sockaddr * _recvfrom_addr = (addr); \
  197.   LONG * _recvfrom_addrlen = (addrlen); \
  198.   LONG _recvfrom__re = \
  199.   ({ \
  200.   register struct Library * const __recvfrom__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  201.   register LONG __recvfrom__re __asm("d0"); \
  202.   register LONG __recvfrom_sock __asm("d0") = (_recvfrom_sock); \
  203.   register APTR __recvfrom_buf __asm("a0") = (_recvfrom_buf); \
  204.   register LONG __recvfrom_len __asm("d1") = (_recvfrom_len); \
  205.   register LONG __recvfrom_flags __asm("d2") = (_recvfrom_flags); \
  206.   register struct sockaddr * __recvfrom_addr __asm("a1") = (_recvfrom_addr); \
  207.   register LONG * __recvfrom_addrlen __asm("a2") = (_recvfrom_addrlen); \
  208.   __asm volatile ("jsr a6@(-72:W)" \
  209.   : "=r"(__recvfrom__re) \
  210.   : "r"(__recvfrom__bn), "r"(__recvfrom_sock), "r"(__recvfrom_buf), "r"(__recvfrom_len), "r"(__recvfrom_flags), "r"(__recvfrom_addr), "r"(__recvfrom_addrlen)  \
  211.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  212.   __recvfrom__re; \
  213.   }); \
  214.   _recvfrom__re; \
  215. })
  216.  
  217. #define recv(sock, buf, len, flags) ({ \
  218.   LONG _recv_sock = (sock); \
  219.   APTR _recv_buf = (buf); \
  220.   LONG _recv_len = (len); \
  221.   LONG _recv_flags = (flags); \
  222.   LONG _recv__re = \
  223.   ({ \
  224.   register struct Library * const __recv__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  225.   register LONG __recv__re __asm("d0"); \
  226.   register LONG __recv_sock __asm("d0") = (_recv_sock); \
  227.   register APTR __recv_buf __asm("a0") = (_recv_buf); \
  228.   register LONG __recv_len __asm("d1") = (_recv_len); \
  229.   register LONG __recv_flags __asm("d2") = (_recv_flags); \
  230.   __asm volatile ("jsr a6@(-78:W)" \
  231.   : "=r"(__recv__re) \
  232.   : "r"(__recv__bn), "r"(__recv_sock), "r"(__recv_buf), "r"(__recv_len), "r"(__recv_flags)  \
  233.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  234.   __recv__re; \
  235.   }); \
  236.   _recv__re; \
  237. })
  238.  
  239. #define shutdown(sock, how) ({ \
  240.   LONG _shutdown_sock = (sock); \
  241.   LONG _shutdown_how = (how); \
  242.   LONG _shutdown__re = \
  243.   ({ \
  244.   register struct Library * const __shutdown__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  245.   register LONG __shutdown__re __asm("d0"); \
  246.   register LONG __shutdown_sock __asm("d0") = (_shutdown_sock); \
  247.   register LONG __shutdown_how __asm("d1") = (_shutdown_how); \
  248.   __asm volatile ("jsr a6@(-84:W)" \
  249.   : "=r"(__shutdown__re) \
  250.   : "r"(__shutdown__bn), "r"(__shutdown_sock), "r"(__shutdown_how)  \
  251.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  252.   __shutdown__re; \
  253.   }); \
  254.   _shutdown__re; \
  255. })
  256.  
  257. #define setsockopt(sock, level, optname, optval, optlen) ({ \
  258.   LONG _setsockopt_sock = (sock); \
  259.   LONG _setsockopt_level = (level); \
  260.   LONG _setsockopt_optname = (optname); \
  261.   APTR _setsockopt_optval = (optval); \
  262.   LONG _setsockopt_optlen = (optlen); \
  263.   LONG _setsockopt__re = \
  264.   ({ \
  265.   register struct Library * const __setsockopt__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  266.   register LONG __setsockopt__re __asm("d0"); \
  267.   register LONG __setsockopt_sock __asm("d0") = (_setsockopt_sock); \
  268.   register LONG __setsockopt_level __asm("d1") = (_setsockopt_level); \
  269.   register LONG __setsockopt_optname __asm("d2") = (_setsockopt_optname); \
  270.   register APTR __setsockopt_optval __asm("a0") = (_setsockopt_optval); \
  271.   register LONG __setsockopt_optlen __asm("d3") = (_setsockopt_optlen); \
  272.   __asm volatile ("jsr a6@(-90:W)" \
  273.   : "=r"(__setsockopt__re) \
  274.   : "r"(__setsockopt__bn), "r"(__setsockopt_sock), "r"(__setsockopt_level), "r"(__setsockopt_optname), "r"(__setsockopt_optval), "r"(__setsockopt_optlen)  \
  275.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  276.   __setsockopt__re; \
  277.   }); \
  278.   _setsockopt__re; \
  279. })
  280.  
  281. #define getsockopt(sock, level, optname, optval, optlen) ({ \
  282.   LONG _getsockopt_sock = (sock); \
  283.   LONG _getsockopt_level = (level); \
  284.   LONG _getsockopt_optname = (optname); \
  285.   APTR _getsockopt_optval = (optval); \
  286.   LONG * _getsockopt_optlen = (optlen); \
  287.   LONG _getsockopt__re = \
  288.   ({ \
  289.   register struct Library * const __getsockopt__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  290.   register LONG __getsockopt__re __asm("d0"); \
  291.   register LONG __getsockopt_sock __asm("d0") = (_getsockopt_sock); \
  292.   register LONG __getsockopt_level __asm("d1") = (_getsockopt_level); \
  293.   register LONG __getsockopt_optname __asm("d2") = (_getsockopt_optname); \
  294.   register APTR __getsockopt_optval __asm("a0") = (_getsockopt_optval); \
  295.   register LONG * __getsockopt_optlen __asm("a1") = (_getsockopt_optlen); \
  296.   __asm volatile ("jsr a6@(-96:W)" \
  297.   : "=r"(__getsockopt__re) \
  298.   : "r"(__getsockopt__bn), "r"(__getsockopt_sock), "r"(__getsockopt_level), "r"(__getsockopt_optname), "r"(__getsockopt_optval), "r"(__getsockopt_optlen)  \
  299.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  300.   __getsockopt__re; \
  301.   }); \
  302.   _getsockopt__re; \
  303. })
  304.  
  305. #define getsockname(sock, name, namelen) ({ \
  306.   LONG _getsockname_sock = (sock); \
  307.   struct sockaddr * _getsockname_name = (name); \
  308.   LONG * _getsockname_namelen = (namelen); \
  309.   LONG _getsockname__re = \
  310.   ({ \
  311.   register struct Library * const __getsockname__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  312.   register LONG __getsockname__re __asm("d0"); \
  313.   register LONG __getsockname_sock __asm("d0") = (_getsockname_sock); \
  314.   register struct sockaddr * __getsockname_name __asm("a0") = (_getsockname_name); \
  315.   register LONG * __getsockname_namelen __asm("a1") = (_getsockname_namelen); \
  316.   __asm volatile ("jsr a6@(-102:W)" \
  317.   : "=r"(__getsockname__re) \
  318.   : "r"(__getsockname__bn), "r"(__getsockname_sock), "r"(__getsockname_name), "r"(__getsockname_namelen)  \
  319.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  320.   __getsockname__re; \
  321.   }); \
  322.   _getsockname__re; \
  323. })
  324.  
  325. #define getpeername(sock, name, namelen) ({ \
  326.   LONG _getpeername_sock = (sock); \
  327.   struct sockaddr * _getpeername_name = (name); \
  328.   LONG * _getpeername_namelen = (namelen); \
  329.   LONG _getpeername__re = \
  330.   ({ \
  331.   register struct Library * const __getpeername__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  332.   register LONG __getpeername__re __asm("d0"); \
  333.   register LONG __getpeername_sock __asm("d0") = (_getpeername_sock); \
  334.   register struct sockaddr * __getpeername_name __asm("a0") = (_getpeername_name); \
  335.   register LONG * __getpeername_namelen __asm("a1") = (_getpeername_namelen); \
  336.   __asm volatile ("jsr a6@(-108:W)" \
  337.   : "=r"(__getpeername__re) \
  338.   : "r"(__getpeername__bn), "r"(__getpeername_sock), "r"(__getpeername_name), "r"(__getpeername_namelen)  \
  339.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  340.   __getpeername__re; \
  341.   }); \
  342.   _getpeername__re; \
  343. })
  344.  
  345. #define IoctlSocket(sock, req, argp) ({ \
  346.   LONG _IoctlSocket_sock = (sock); \
  347.   ULONG _IoctlSocket_req = (req); \
  348.   APTR _IoctlSocket_argp = (argp); \
  349.   LONG _IoctlSocket__re = \
  350.   ({ \
  351.   register struct Library * const __IoctlSocket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  352.   register LONG __IoctlSocket__re __asm("d0"); \
  353.   register LONG __IoctlSocket_sock __asm("d0") = (_IoctlSocket_sock); \
  354.   register ULONG __IoctlSocket_req __asm("d1") = (_IoctlSocket_req); \
  355.   register APTR __IoctlSocket_argp __asm("a0") = (_IoctlSocket_argp); \
  356.   __asm volatile ("jsr a6@(-114:W)" \
  357.   : "=r"(__IoctlSocket__re) \
  358.   : "r"(__IoctlSocket__bn), "r"(__IoctlSocket_sock), "r"(__IoctlSocket_req), "r"(__IoctlSocket_argp)  \
  359.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  360.   __IoctlSocket__re; \
  361.   }); \
  362.   _IoctlSocket__re; \
  363. })
  364.  
  365. #define CloseSocket(sock) ({ \
  366.   LONG _CloseSocket_sock = (sock); \
  367.   LONG _CloseSocket__re = \
  368.   ({ \
  369.   register struct Library * const __CloseSocket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  370.   register LONG __CloseSocket__re __asm("d0"); \
  371.   register LONG __CloseSocket_sock __asm("d0") = (_CloseSocket_sock); \
  372.   __asm volatile ("jsr a6@(-120:W)" \
  373.   : "=r"(__CloseSocket__re) \
  374.   : "r"(__CloseSocket__bn), "r"(__CloseSocket_sock)  \
  375.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  376.   __CloseSocket__re; \
  377.   }); \
  378.   _CloseSocket__re; \
  379. })
  380.  
  381. #define WaitSelect(nfds, read_fds, write_fds, except_fds, timeout, signals) ({ \
  382.   LONG _WaitSelect_nfds = (nfds); \
  383.   APTR _WaitSelect_read_fds = (read_fds); \
  384.   APTR _WaitSelect_write_fds = (write_fds); \
  385.   APTR _WaitSelect_except_fds = (except_fds); \
  386.   struct timeval * _WaitSelect_timeout = (timeout); \
  387.   ULONG * _WaitSelect_signals = (signals); \
  388.   LONG _WaitSelect__re = \
  389.   ({ \
  390.   register struct Library * const __WaitSelect__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  391.   register LONG __WaitSelect__re __asm("d0"); \
  392.   register LONG __WaitSelect_nfds __asm("d0") = (_WaitSelect_nfds); \
  393.   register APTR __WaitSelect_read_fds __asm("a0") = (_WaitSelect_read_fds); \
  394.   register APTR __WaitSelect_write_fds __asm("a1") = (_WaitSelect_write_fds); \
  395.   register APTR __WaitSelect_except_fds __asm("a2") = (_WaitSelect_except_fds); \
  396.   register struct timeval * __WaitSelect_timeout __asm("a3") = (_WaitSelect_timeout); \
  397.   register ULONG * __WaitSelect_signals __asm("d1") = (_WaitSelect_signals); \
  398.   __asm volatile ("jsr a6@(-126:W)" \
  399.   : "=r"(__WaitSelect__re) \
  400.   : "r"(__WaitSelect__bn), "r"(__WaitSelect_nfds), "r"(__WaitSelect_read_fds), "r"(__WaitSelect_write_fds), "r"(__WaitSelect_except_fds), "r"(__WaitSelect_timeout), "r"(__WaitSelect_signals)  \
  401.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  402.   __WaitSelect__re; \
  403.   }); \
  404.   _WaitSelect__re; \
  405. })
  406.  
  407. #define SetSocketSignals(int_mask, io_mask, urgent_mask) ({ \
  408.   ULONG _SetSocketSignals_int_mask = (int_mask); \
  409.   ULONG _SetSocketSignals_io_mask = (io_mask); \
  410.   ULONG _SetSocketSignals_urgent_mask = (urgent_mask); \
  411.   { \
  412.   register struct Library * const __SetSocketSignals__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  413.   register ULONG __SetSocketSignals_int_mask __asm("d0") = (_SetSocketSignals_int_mask); \
  414.   register ULONG __SetSocketSignals_io_mask __asm("d1") = (_SetSocketSignals_io_mask); \
  415.   register ULONG __SetSocketSignals_urgent_mask __asm("d2") = (_SetSocketSignals_urgent_mask); \
  416.   __asm volatile ("jsr a6@(-132:W)" \
  417.   : \
  418.   : "r"(__SetSocketSignals__bn), "r"(__SetSocketSignals_int_mask), "r"(__SetSocketSignals_io_mask), "r"(__SetSocketSignals_urgent_mask)  \
  419.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  420.   } \
  421. })
  422.  
  423. #define getdtablesize() ({ \
  424.   LONG _getdtablesize__re = \
  425.   ({ \
  426.   register struct Library * const __getdtablesize__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  427.   register LONG __getdtablesize__re __asm("d0"); \
  428.   __asm volatile ("jsr a6@(-138:W)" \
  429.   : "=r"(__getdtablesize__re) \
  430.   : "r"(__getdtablesize__bn)  \
  431.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  432.   __getdtablesize__re; \
  433.   }); \
  434.   _getdtablesize__re; \
  435. })
  436.  
  437. #define ObtainSocket(id, domain, type, protocol) ({ \
  438.   LONG _ObtainSocket_id = (id); \
  439.   LONG _ObtainSocket_domain = (domain); \
  440.   LONG _ObtainSocket_type = (type); \
  441.   LONG _ObtainSocket_protocol = (protocol); \
  442.   LONG _ObtainSocket__re = \
  443.   ({ \
  444.   register struct Library * const __ObtainSocket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  445.   register LONG __ObtainSocket__re __asm("d0"); \
  446.   register LONG __ObtainSocket_id __asm("d0") = (_ObtainSocket_id); \
  447.   register LONG __ObtainSocket_domain __asm("d1") = (_ObtainSocket_domain); \
  448.   register LONG __ObtainSocket_type __asm("d2") = (_ObtainSocket_type); \
  449.   register LONG __ObtainSocket_protocol __asm("d3") = (_ObtainSocket_protocol); \
  450.   __asm volatile ("jsr a6@(-144:W)" \
  451.   : "=r"(__ObtainSocket__re) \
  452.   : "r"(__ObtainSocket__bn), "r"(__ObtainSocket_id), "r"(__ObtainSocket_domain), "r"(__ObtainSocket_type), "r"(__ObtainSocket_protocol)  \
  453.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  454.   __ObtainSocket__re; \
  455.   }); \
  456.   _ObtainSocket__re; \
  457. })
  458.  
  459. #define ReleaseSocket(sock, id) ({ \
  460.   LONG _ReleaseSocket_sock = (sock); \
  461.   LONG _ReleaseSocket_id = (id); \
  462.   LONG _ReleaseSocket__re = \
  463.   ({ \
  464.   register struct Library * const __ReleaseSocket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  465.   register LONG __ReleaseSocket__re __asm("d0"); \
  466.   register LONG __ReleaseSocket_sock __asm("d0") = (_ReleaseSocket_sock); \
  467.   register LONG __ReleaseSocket_id __asm("d1") = (_ReleaseSocket_id); \
  468.   __asm volatile ("jsr a6@(-150:W)" \
  469.   : "=r"(__ReleaseSocket__re) \
  470.   : "r"(__ReleaseSocket__bn), "r"(__ReleaseSocket_sock), "r"(__ReleaseSocket_id)  \
  471.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  472.   __ReleaseSocket__re; \
  473.   }); \
  474.   _ReleaseSocket__re; \
  475. })
  476.  
  477. #define ReleaseCopyOfSocket(sock, id) ({ \
  478.   LONG _ReleaseCopyOfSocket_sock = (sock); \
  479.   LONG _ReleaseCopyOfSocket_id = (id); \
  480.   LONG _ReleaseCopyOfSocket__re = \
  481.   ({ \
  482.   register struct Library * const __ReleaseCopyOfSocket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  483.   register LONG __ReleaseCopyOfSocket__re __asm("d0"); \
  484.   register LONG __ReleaseCopyOfSocket_sock __asm("d0") = (_ReleaseCopyOfSocket_sock); \
  485.   register LONG __ReleaseCopyOfSocket_id __asm("d1") = (_ReleaseCopyOfSocket_id); \
  486.   __asm volatile ("jsr a6@(-156:W)" \
  487.   : "=r"(__ReleaseCopyOfSocket__re) \
  488.   : "r"(__ReleaseCopyOfSocket__bn), "r"(__ReleaseCopyOfSocket_sock), "r"(__ReleaseCopyOfSocket_id)  \
  489.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  490.   __ReleaseCopyOfSocket__re; \
  491.   }); \
  492.   _ReleaseCopyOfSocket__re; \
  493. })
  494.  
  495. #define Errno() ({ \
  496.   LONG _Errno__re = \
  497.   ({ \
  498.   register struct Library * const __Errno__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  499.   register LONG __Errno__re __asm("d0"); \
  500.   __asm volatile ("jsr a6@(-162:W)" \
  501.   : "=r"(__Errno__re) \
  502.   : "r"(__Errno__bn)  \
  503.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  504.   __Errno__re; \
  505.   }); \
  506.   _Errno__re; \
  507. })
  508.  
  509. #define SetErrnoPtr(errno_ptr, size) ({ \
  510.   APTR _SetErrnoPtr_errno_ptr = (errno_ptr); \
  511.   LONG _SetErrnoPtr_size = (size); \
  512.   { \
  513.   register struct Library * const __SetErrnoPtr__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  514.   register APTR __SetErrnoPtr_errno_ptr __asm("a0") = (_SetErrnoPtr_errno_ptr); \
  515.   register LONG __SetErrnoPtr_size __asm("d0") = (_SetErrnoPtr_size); \
  516.   __asm volatile ("jsr a6@(-168:W)" \
  517.   : \
  518.   : "r"(__SetErrnoPtr__bn), "r"(__SetErrnoPtr_errno_ptr), "r"(__SetErrnoPtr_size)  \
  519.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  520.   } \
  521. })
  522.  
  523. #define Inet_NtoA(ip) ({ \
  524.   ULONG _Inet_NtoA_ip = (ip); \
  525.   STRPTR _Inet_NtoA__re = \
  526.   ({ \
  527.   register struct Library * const __Inet_NtoA__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  528.   register STRPTR __Inet_NtoA__re __asm("d0"); \
  529.   register ULONG __Inet_NtoA_ip __asm("d0") = (_Inet_NtoA_ip); \
  530.   __asm volatile ("jsr a6@(-174:W)" \
  531.   : "=r"(__Inet_NtoA__re) \
  532.   : "r"(__Inet_NtoA__bn), "r"(__Inet_NtoA_ip)  \
  533.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  534.   __Inet_NtoA__re; \
  535.   }); \
  536.   _Inet_NtoA__re; \
  537. })
  538.  
  539. #define inet_addr(cp) ({ \
  540.   STRPTR _inet_addr_cp = (cp); \
  541.   ULONG _inet_addr__re = \
  542.   ({ \
  543.   register struct Library * const __inet_addr__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  544.   register ULONG __inet_addr__re __asm("d0"); \
  545.   register STRPTR __inet_addr_cp __asm("a0") = (_inet_addr_cp); \
  546.   __asm volatile ("jsr a6@(-180:W)" \
  547.   : "=r"(__inet_addr__re) \
  548.   : "r"(__inet_addr__bn), "r"(__inet_addr_cp)  \
  549.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  550.   __inet_addr__re; \
  551.   }); \
  552.   _inet_addr__re; \
  553. })
  554.  
  555. #define Inet_LnaOf(in) ({ \
  556.   ULONG _Inet_LnaOf_in = (in); \
  557.   ULONG _Inet_LnaOf__re = \
  558.   ({ \
  559.   register struct Library * const __Inet_LnaOf__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  560.   register ULONG __Inet_LnaOf__re __asm("d0"); \
  561.   register ULONG __Inet_LnaOf_in __asm("d0") = (_Inet_LnaOf_in); \
  562.   __asm volatile ("jsr a6@(-186:W)" \
  563.   : "=r"(__Inet_LnaOf__re) \
  564.   : "r"(__Inet_LnaOf__bn), "r"(__Inet_LnaOf_in)  \
  565.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  566.   __Inet_LnaOf__re; \
  567.   }); \
  568.   _Inet_LnaOf__re; \
  569. })
  570.  
  571. #define Inet_NetOf(in) ({ \
  572.   ULONG _Inet_NetOf_in = (in); \
  573.   ULONG _Inet_NetOf__re = \
  574.   ({ \
  575.   register struct Library * const __Inet_NetOf__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  576.   register ULONG __Inet_NetOf__re __asm("d0"); \
  577.   register ULONG __Inet_NetOf_in __asm("d0") = (_Inet_NetOf_in); \
  578.   __asm volatile ("jsr a6@(-192:W)" \
  579.   : "=r"(__Inet_NetOf__re) \
  580.   : "r"(__Inet_NetOf__bn), "r"(__Inet_NetOf_in)  \
  581.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  582.   __Inet_NetOf__re; \
  583.   }); \
  584.   _Inet_NetOf__re; \
  585. })
  586.  
  587. #define Inet_MakeAddr(net, host) ({ \
  588.   ULONG _Inet_MakeAddr_net = (net); \
  589.   ULONG _Inet_MakeAddr_host = (host); \
  590.   ULONG _Inet_MakeAddr__re = \
  591.   ({ \
  592.   register struct Library * const __Inet_MakeAddr__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  593.   register ULONG __Inet_MakeAddr__re __asm("d0"); \
  594.   register ULONG __Inet_MakeAddr_net __asm("d0") = (_Inet_MakeAddr_net); \
  595.   register ULONG __Inet_MakeAddr_host __asm("d1") = (_Inet_MakeAddr_host); \
  596.   __asm volatile ("jsr a6@(-198:W)" \
  597.   : "=r"(__Inet_MakeAddr__re) \
  598.   : "r"(__Inet_MakeAddr__bn), "r"(__Inet_MakeAddr_net), "r"(__Inet_MakeAddr_host)  \
  599.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  600.   __Inet_MakeAddr__re; \
  601.   }); \
  602.   _Inet_MakeAddr__re; \
  603. })
  604.  
  605. #define inet_network(cp) ({ \
  606.   STRPTR _inet_network_cp = (cp); \
  607.   ULONG _inet_network__re = \
  608.   ({ \
  609.   register struct Library * const __inet_network__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  610.   register ULONG __inet_network__re __asm("d0"); \
  611.   register STRPTR __inet_network_cp __asm("a0") = (_inet_network_cp); \
  612.   __asm volatile ("jsr a6@(-204:W)" \
  613.   : "=r"(__inet_network__re) \
  614.   : "r"(__inet_network__bn), "r"(__inet_network_cp)  \
  615.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  616.   __inet_network__re; \
  617.   }); \
  618.   _inet_network__re; \
  619. })
  620.  
  621. #define gethostbyname(name) ({ \
  622.   STRPTR _gethostbyname_name = (name); \
  623.   struct hostent * _gethostbyname__re = \
  624.   ({ \
  625.   register struct Library * const __gethostbyname__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  626.   register struct hostent * __gethostbyname__re __asm("d0"); \
  627.   register STRPTR __gethostbyname_name __asm("a0") = (_gethostbyname_name); \
  628.   __asm volatile ("jsr a6@(-210:W)" \
  629.   : "=r"(__gethostbyname__re) \
  630.   : "r"(__gethostbyname__bn), "r"(__gethostbyname_name)  \
  631.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  632.   __gethostbyname__re; \
  633.   }); \
  634.   _gethostbyname__re; \
  635. })
  636.  
  637. #define gethostbyaddr(addr, len, type) ({ \
  638.   STRPTR _gethostbyaddr_addr = (addr); \
  639.   LONG _gethostbyaddr_len = (len); \
  640.   LONG _gethostbyaddr_type = (type); \
  641.   struct hostent * _gethostbyaddr__re = \
  642.   ({ \
  643.   register struct Library * const __gethostbyaddr__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  644.   register struct hostent * __gethostbyaddr__re __asm("d0"); \
  645.   register STRPTR __gethostbyaddr_addr __asm("a0") = (_gethostbyaddr_addr); \
  646.   register LONG __gethostbyaddr_len __asm("d0") = (_gethostbyaddr_len); \
  647.   register LONG __gethostbyaddr_type __asm("d1") = (_gethostbyaddr_type); \
  648.   __asm volatile ("jsr a6@(-216:W)" \
  649.   : "=r"(__gethostbyaddr__re) \
  650.   : "r"(__gethostbyaddr__bn), "r"(__gethostbyaddr_addr), "r"(__gethostbyaddr_len), "r"(__gethostbyaddr_type)  \
  651.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  652.   __gethostbyaddr__re; \
  653.   }); \
  654.   _gethostbyaddr__re; \
  655. })
  656.  
  657. #define getnetbyname(name) ({ \
  658.   STRPTR _getnetbyname_name = (name); \
  659.   struct netent * _getnetbyname__re = \
  660.   ({ \
  661.   register struct Library * const __getnetbyname__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  662.   register struct netent * __getnetbyname__re __asm("d0"); \
  663.   register STRPTR __getnetbyname_name __asm("a0") = (_getnetbyname_name); \
  664.   __asm volatile ("jsr a6@(-222:W)" \
  665.   : "=r"(__getnetbyname__re) \
  666.   : "r"(__getnetbyname__bn), "r"(__getnetbyname_name)  \
  667.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  668.   __getnetbyname__re; \
  669.   }); \
  670.   _getnetbyname__re; \
  671. })
  672.  
  673. #define getnetbyaddr(net, type) ({ \
  674.   ULONG _getnetbyaddr_net = (net); \
  675.   LONG _getnetbyaddr_type = (type); \
  676.   struct netent * _getnetbyaddr__re = \
  677.   ({ \
  678.   register struct Library * const __getnetbyaddr__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  679.   register struct netent * __getnetbyaddr__re __asm("d0"); \
  680.   register ULONG __getnetbyaddr_net __asm("d0") = (_getnetbyaddr_net); \
  681.   register LONG __getnetbyaddr_type __asm("d1") = (_getnetbyaddr_type); \
  682.   __asm volatile ("jsr a6@(-228:W)" \
  683.   : "=r"(__getnetbyaddr__re) \
  684.   : "r"(__getnetbyaddr__bn), "r"(__getnetbyaddr_net), "r"(__getnetbyaddr_type)  \
  685.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  686.   __getnetbyaddr__re; \
  687.   }); \
  688.   _getnetbyaddr__re; \
  689. })
  690.  
  691. #define getservbyname(name, proto) ({ \
  692.   STRPTR _getservbyname_name = (name); \
  693.   STRPTR _getservbyname_proto = (proto); \
  694.   struct servent * _getservbyname__re = \
  695.   ({ \
  696.   register struct Library * const __getservbyname__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  697.   register struct servent * __getservbyname__re __asm("d0"); \
  698.   register STRPTR __getservbyname_name __asm("a0") = (_getservbyname_name); \
  699.   register STRPTR __getservbyname_proto __asm("a1") = (_getservbyname_proto); \
  700.   __asm volatile ("jsr a6@(-234:W)" \
  701.   : "=r"(__getservbyname__re) \
  702.   : "r"(__getservbyname__bn), "r"(__getservbyname_name), "r"(__getservbyname_proto)  \
  703.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  704.   __getservbyname__re; \
  705.   }); \
  706.   _getservbyname__re; \
  707. })
  708.  
  709. #define getservbyport(port, proto) ({ \
  710.   LONG _getservbyport_port = (port); \
  711.   STRPTR _getservbyport_proto = (proto); \
  712.   struct servent * _getservbyport__re = \
  713.   ({ \
  714.   register struct Library * const __getservbyport__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  715.   register struct servent * __getservbyport__re __asm("d0"); \
  716.   register LONG __getservbyport_port __asm("d0") = (_getservbyport_port); \
  717.   register STRPTR __getservbyport_proto __asm("a0") = (_getservbyport_proto); \
  718.   __asm volatile ("jsr a6@(-240:W)" \
  719.   : "=r"(__getservbyport__re) \
  720.   : "r"(__getservbyport__bn), "r"(__getservbyport_port), "r"(__getservbyport_proto)  \
  721.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  722.   __getservbyport__re; \
  723.   }); \
  724.   _getservbyport__re; \
  725. })
  726.  
  727. #define getprotobyname(name) ({ \
  728.   STRPTR _getprotobyname_name = (name); \
  729.   struct protoent * _getprotobyname__re = \
  730.   ({ \
  731.   register struct Library * const __getprotobyname__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  732.   register struct protoent * __getprotobyname__re __asm("d0"); \
  733.   register STRPTR __getprotobyname_name __asm("a0") = (_getprotobyname_name); \
  734.   __asm volatile ("jsr a6@(-246:W)" \
  735.   : "=r"(__getprotobyname__re) \
  736.   : "r"(__getprotobyname__bn), "r"(__getprotobyname_name)  \
  737.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  738.   __getprotobyname__re; \
  739.   }); \
  740.   _getprotobyname__re; \
  741. })
  742.  
  743. #define getprotobynumber(proto) ({ \
  744.   LONG _getprotobynumber_proto = (proto); \
  745.   struct protoent * _getprotobynumber__re = \
  746.   ({ \
  747.   register struct Library * const __getprotobynumber__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  748.   register struct protoent * __getprotobynumber__re __asm("d0"); \
  749.   register LONG __getprotobynumber_proto __asm("d0") = (_getprotobynumber_proto); \
  750.   __asm volatile ("jsr a6@(-252:W)" \
  751.   : "=r"(__getprotobynumber__re) \
  752.   : "r"(__getprotobynumber__bn), "r"(__getprotobynumber_proto)  \
  753.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  754.   __getprotobynumber__re; \
  755.   }); \
  756.   _getprotobynumber__re; \
  757. })
  758.  
  759. #define vsyslog(pri, msg, args) ({ \
  760.   LONG _vsyslog_pri = (pri); \
  761.   STRPTR _vsyslog_msg = (msg); \
  762.   APTR _vsyslog_args = (args); \
  763.   { \
  764.   register struct Library * const __vsyslog__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  765.   register LONG __vsyslog_pri __asm("d0") = (_vsyslog_pri); \
  766.   register STRPTR __vsyslog_msg __asm("a0") = (_vsyslog_msg); \
  767.   register APTR __vsyslog_args __asm("a1") = (_vsyslog_args); \
  768.   __asm volatile ("jsr a6@(-258:W)" \
  769.   : \
  770.   : "r"(__vsyslog__bn), "r"(__vsyslog_pri), "r"(__vsyslog_msg), "r"(__vsyslog_args)  \
  771.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  772.   } \
  773. })
  774.  
  775. #ifndef NO_INLINE_STDARG
  776. static __inline__ VOID ___syslog(struct Library * SocketBase, LONG pri, STRPTR msg, ...)
  777. {
  778.   vsyslog(pri, msg, (APTR) ((ULONG) &msg + sizeof(STRPTR)));
  779. }
  780.  
  781. #define syslog(pri, msg, tags...) ___syslog(BSDSOCKET_BASE_NAME, pri, msg, tags)
  782. #endif
  783.  
  784. #define Dup2Socket(old_socket, new_socket) ({ \
  785.   LONG _Dup2Socket_old_socket = (old_socket); \
  786.   LONG _Dup2Socket_new_socket = (new_socket); \
  787.   LONG _Dup2Socket__re = \
  788.   ({ \
  789.   register struct Library * const __Dup2Socket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  790.   register LONG __Dup2Socket__re __asm("d0"); \
  791.   register LONG __Dup2Socket_old_socket __asm("d0") = (_Dup2Socket_old_socket); \
  792.   register LONG __Dup2Socket_new_socket __asm("d1") = (_Dup2Socket_new_socket); \
  793.   __asm volatile ("jsr a6@(-264:W)" \
  794.   : "=r"(__Dup2Socket__re) \
  795.   : "r"(__Dup2Socket__bn), "r"(__Dup2Socket_old_socket), "r"(__Dup2Socket_new_socket)  \
  796.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  797.   __Dup2Socket__re; \
  798.   }); \
  799.   _Dup2Socket__re; \
  800. })
  801.  
  802. #define sendmsg(sock, msg, flags) ({ \
  803.   LONG _sendmsg_sock = (sock); \
  804.   struct msghdr * _sendmsg_msg = (msg); \
  805.   LONG _sendmsg_flags = (flags); \
  806.   LONG _sendmsg__re = \
  807.   ({ \
  808.   register struct Library * const __sendmsg__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  809.   register LONG __sendmsg__re __asm("d0"); \
  810.   register LONG __sendmsg_sock __asm("d0") = (_sendmsg_sock); \
  811.   register struct msghdr * __sendmsg_msg __asm("a0") = (_sendmsg_msg); \
  812.   register LONG __sendmsg_flags __asm("d1") = (_sendmsg_flags); \
  813.   __asm volatile ("jsr a6@(-270:W)" \
  814.   : "=r"(__sendmsg__re) \
  815.   : "r"(__sendmsg__bn), "r"(__sendmsg_sock), "r"(__sendmsg_msg), "r"(__sendmsg_flags)  \
  816.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  817.   __sendmsg__re; \
  818.   }); \
  819.   _sendmsg__re; \
  820. })
  821.  
  822. #define recvmsg(sock, msg, flags) ({ \
  823.   LONG _recvmsg_sock = (sock); \
  824.   struct msghdr * _recvmsg_msg = (msg); \
  825.   LONG _recvmsg_flags = (flags); \
  826.   LONG _recvmsg__re = \
  827.   ({ \
  828.   register struct Library * const __recvmsg__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  829.   register LONG __recvmsg__re __asm("d0"); \
  830.   register LONG __recvmsg_sock __asm("d0") = (_recvmsg_sock); \
  831.   register struct msghdr * __recvmsg_msg __asm("a0") = (_recvmsg_msg); \
  832.   register LONG __recvmsg_flags __asm("d1") = (_recvmsg_flags); \
  833.   __asm volatile ("jsr a6@(-276:W)" \
  834.   : "=r"(__recvmsg__re) \
  835.   : "r"(__recvmsg__bn), "r"(__recvmsg_sock), "r"(__recvmsg_msg), "r"(__recvmsg_flags)  \
  836.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  837.   __recvmsg__re; \
  838.   }); \
  839.   _recvmsg__re; \
  840. })
  841.  
  842. #define gethostname(name, namelen) ({ \
  843.   STRPTR _gethostname_name = (name); \
  844.   LONG _gethostname_namelen = (namelen); \
  845.   LONG _gethostname__re = \
  846.   ({ \
  847.   register struct Library * const __gethostname__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  848.   register LONG __gethostname__re __asm("d0"); \
  849.   register STRPTR __gethostname_name __asm("a0") = (_gethostname_name); \
  850.   register LONG __gethostname_namelen __asm("d0") = (_gethostname_namelen); \
  851.   __asm volatile ("jsr a6@(-282:W)" \
  852.   : "=r"(__gethostname__re) \
  853.   : "r"(__gethostname__bn), "r"(__gethostname_name), "r"(__gethostname_namelen)  \
  854.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  855.   __gethostname__re; \
  856.   }); \
  857.   _gethostname__re; \
  858. })
  859.  
  860. #define gethostid() ({ \
  861.   ULONG _gethostid__re = \
  862.   ({ \
  863.   register struct Library * const __gethostid__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  864.   register ULONG __gethostid__re __asm("d0"); \
  865.   __asm volatile ("jsr a6@(-288:W)" \
  866.   : "=r"(__gethostid__re) \
  867.   : "r"(__gethostid__bn)  \
  868.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  869.   __gethostid__re; \
  870.   }); \
  871.   _gethostid__re; \
  872. })
  873.  
  874. #define SocketBaseTagList(tags) ({ \
  875.   struct TagItem * _SocketBaseTagList_tags = (tags); \
  876.   LONG _SocketBaseTagList__re = \
  877.   ({ \
  878.   register struct Library * const __SocketBaseTagList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  879.   register LONG __SocketBaseTagList__re __asm("d0"); \
  880.   register struct TagItem * __SocketBaseTagList_tags __asm("a0") = (_SocketBaseTagList_tags); \
  881.   __asm volatile ("jsr a6@(-294:W)" \
  882.   : "=r"(__SocketBaseTagList__re) \
  883.   : "r"(__SocketBaseTagList__bn), "r"(__SocketBaseTagList_tags)  \
  884.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  885.   __SocketBaseTagList__re; \
  886.   }); \
  887.   _SocketBaseTagList__re; \
  888. })
  889.  
  890. #ifndef NO_INLINE_STDARG
  891. static __inline__ LONG ___SocketBaseTags(struct Library * SocketBase, ULONG tag, ...)
  892. {
  893.   return SocketBaseTagList((struct TagItem *) &tag);
  894. }
  895.  
  896. #define SocketBaseTags(tags...) ___SocketBaseTags(BSDSOCKET_BASE_NAME, tags)
  897. #endif
  898.  
  899. #define GetSocketEvents(event_ptr) ({ \
  900.   ULONG * _GetSocketEvents_event_ptr = (event_ptr); \
  901.   LONG _GetSocketEvents__re = \
  902.   ({ \
  903.   register struct Library * const __GetSocketEvents__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  904.   register LONG __GetSocketEvents__re __asm("d0"); \
  905.   register ULONG * __GetSocketEvents_event_ptr __asm("a0") = (_GetSocketEvents_event_ptr); \
  906.   __asm volatile ("jsr a6@(-300:W)" \
  907.   : "=r"(__GetSocketEvents__re) \
  908.   : "r"(__GetSocketEvents__bn), "r"(__GetSocketEvents_event_ptr)  \
  909.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  910.   __GetSocketEvents__re; \
  911.   }); \
  912.   _GetSocketEvents__re; \
  913. })
  914.  
  915. #define bpf_open(channel) ({ \
  916.   LONG _bpf_open_channel = (channel); \
  917.   LONG _bpf_open__re = \
  918.   ({ \
  919.   register struct Library * const __bpf_open__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  920.   register LONG __bpf_open__re __asm("d0"); \
  921.   register LONG __bpf_open_channel __asm("d0") = (_bpf_open_channel); \
  922.   __asm volatile ("jsr a6@(-366:W)" \
  923.   : "=r"(__bpf_open__re) \
  924.   : "r"(__bpf_open__bn), "r"(__bpf_open_channel)  \
  925.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  926.   __bpf_open__re; \
  927.   }); \
  928.   _bpf_open__re; \
  929. })
  930.  
  931. #define bpf_close(channel) ({ \
  932.   LONG _bpf_close_channel = (channel); \
  933.   LONG _bpf_close__re = \
  934.   ({ \
  935.   register struct Library * const __bpf_close__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  936.   register LONG __bpf_close__re __asm("d0"); \
  937.   register LONG __bpf_close_channel __asm("d0") = (_bpf_close_channel); \
  938.   __asm volatile ("jsr a6@(-372:W)" \
  939.   : "=r"(__bpf_close__re) \
  940.   : "r"(__bpf_close__bn), "r"(__bpf_close_channel)  \
  941.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  942.   __bpf_close__re; \
  943.   }); \
  944.   _bpf_close__re; \
  945. })
  946.  
  947. #define bpf_read(channel, buffer, len) ({ \
  948.   LONG _bpf_read_channel = (channel); \
  949.   APTR _bpf_read_buffer = (buffer); \
  950.   LONG _bpf_read_len = (len); \
  951.   LONG _bpf_read__re = \
  952.   ({ \
  953.   register struct Library * const __bpf_read__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  954.   register LONG __bpf_read__re __asm("d0"); \
  955.   register LONG __bpf_read_channel __asm("d0") = (_bpf_read_channel); \
  956.   register APTR __bpf_read_buffer __asm("a0") = (_bpf_read_buffer); \
  957.   register LONG __bpf_read_len __asm("d1") = (_bpf_read_len); \
  958.   __asm volatile ("jsr a6@(-378:W)" \
  959.   : "=r"(__bpf_read__re) \
  960.   : "r"(__bpf_read__bn), "r"(__bpf_read_channel), "r"(__bpf_read_buffer), "r"(__bpf_read_len)  \
  961.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  962.   __bpf_read__re; \
  963.   }); \
  964.   _bpf_read__re; \
  965. })
  966.  
  967. #define bpf_write(channel, buffer, len) ({ \
  968.   LONG _bpf_write_channel = (channel); \
  969.   APTR _bpf_write_buffer = (buffer); \
  970.   LONG _bpf_write_len = (len); \
  971.   LONG _bpf_write__re = \
  972.   ({ \
  973.   register struct Library * const __bpf_write__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  974.   register LONG __bpf_write__re __asm("d0"); \
  975.   register LONG __bpf_write_channel __asm("d0") = (_bpf_write_channel); \
  976.   register APTR __bpf_write_buffer __asm("a0") = (_bpf_write_buffer); \
  977.   register LONG __bpf_write_len __asm("d1") = (_bpf_write_len); \
  978.   __asm volatile ("jsr a6@(-384:W)" \
  979.   : "=r"(__bpf_write__re) \
  980.   : "r"(__bpf_write__bn), "r"(__bpf_write_channel), "r"(__bpf_write_buffer), "r"(__bpf_write_len)  \
  981.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  982.   __bpf_write__re; \
  983.   }); \
  984.   _bpf_write__re; \
  985. })
  986.  
  987. #define bpf_set_notify_mask(channel, signal_mask) ({ \
  988.   LONG _bpf_set_notify_mask_channel = (channel); \
  989.   ULONG _bpf_set_notify_mask_signal_mask = (signal_mask); \
  990.   LONG _bpf_set_notify_mask__re = \
  991.   ({ \
  992.   register struct Library * const __bpf_set_notify_mask__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  993.   register LONG __bpf_set_notify_mask__re __asm("d0"); \
  994.   register LONG __bpf_set_notify_mask_channel __asm("d1") = (_bpf_set_notify_mask_channel); \
  995.   register ULONG __bpf_set_notify_mask_signal_mask __asm("d0") = (_bpf_set_notify_mask_signal_mask); \
  996.   __asm volatile ("jsr a6@(-390:W)" \
  997.   : "=r"(__bpf_set_notify_mask__re) \
  998.   : "r"(__bpf_set_notify_mask__bn), "r"(__bpf_set_notify_mask_channel), "r"(__bpf_set_notify_mask_signal_mask)  \
  999.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1000.   __bpf_set_notify_mask__re; \
  1001.   }); \
  1002.   _bpf_set_notify_mask__re; \
  1003. })
  1004.  
  1005. #define bpf_set_interrupt_mask(channel, signal_mask) ({ \
  1006.   LONG _bpf_set_interrupt_mask_channel = (channel); \
  1007.   ULONG _bpf_set_interrupt_mask_signal_mask = (signal_mask); \
  1008.   LONG _bpf_set_interrupt_mask__re = \
  1009.   ({ \
  1010.   register struct Library * const __bpf_set_interrupt_mask__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1011.   register LONG __bpf_set_interrupt_mask__re __asm("d0"); \
  1012.   register LONG __bpf_set_interrupt_mask_channel __asm("d0") = (_bpf_set_interrupt_mask_channel); \
  1013.   register ULONG __bpf_set_interrupt_mask_signal_mask __asm("d1") = (_bpf_set_interrupt_mask_signal_mask); \
  1014.   __asm volatile ("jsr a6@(-396:W)" \
  1015.   : "=r"(__bpf_set_interrupt_mask__re) \
  1016.   : "r"(__bpf_set_interrupt_mask__bn), "r"(__bpf_set_interrupt_mask_channel), "r"(__bpf_set_interrupt_mask_signal_mask)  \
  1017.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1018.   __bpf_set_interrupt_mask__re; \
  1019.   }); \
  1020.   _bpf_set_interrupt_mask__re; \
  1021. })
  1022.  
  1023. #define bpf_ioctl(channel, command, buffer) ({ \
  1024.   LONG _bpf_ioctl_channel = (channel); \
  1025.   ULONG _bpf_ioctl_command = (command); \
  1026.   APTR _bpf_ioctl_buffer = (buffer); \
  1027.   LONG _bpf_ioctl__re = \
  1028.   ({ \
  1029.   register struct Library * const __bpf_ioctl__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1030.   register LONG __bpf_ioctl__re __asm("d0"); \
  1031.   register LONG __bpf_ioctl_channel __asm("d0") = (_bpf_ioctl_channel); \
  1032.   register ULONG __bpf_ioctl_command __asm("d1") = (_bpf_ioctl_command); \
  1033.   register APTR __bpf_ioctl_buffer __asm("a0") = (_bpf_ioctl_buffer); \
  1034.   __asm volatile ("jsr a6@(-402:W)" \
  1035.   : "=r"(__bpf_ioctl__re) \
  1036.   : "r"(__bpf_ioctl__bn), "r"(__bpf_ioctl_channel), "r"(__bpf_ioctl_command), "r"(__bpf_ioctl_buffer)  \
  1037.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1038.   __bpf_ioctl__re; \
  1039.   }); \
  1040.   _bpf_ioctl__re; \
  1041. })
  1042.  
  1043. #define bpf_data_waiting(channel) ({ \
  1044.   LONG _bpf_data_waiting_channel = (channel); \
  1045.   LONG _bpf_data_waiting__re = \
  1046.   ({ \
  1047.   register struct Library * const __bpf_data_waiting__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1048.   register LONG __bpf_data_waiting__re __asm("d0"); \
  1049.   register LONG __bpf_data_waiting_channel __asm("d0") = (_bpf_data_waiting_channel); \
  1050.   __asm volatile ("jsr a6@(-408:W)" \
  1051.   : "=r"(__bpf_data_waiting__re) \
  1052.   : "r"(__bpf_data_waiting__bn), "r"(__bpf_data_waiting_channel)  \
  1053.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1054.   __bpf_data_waiting__re; \
  1055.   }); \
  1056.   _bpf_data_waiting__re; \
  1057. })
  1058.  
  1059. #define AddRouteTagList(tags) ({ \
  1060.   struct TagItem * _AddRouteTagList_tags = (tags); \
  1061.   LONG _AddRouteTagList__re = \
  1062.   ({ \
  1063.   register struct Library * const __AddRouteTagList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1064.   register LONG __AddRouteTagList__re __asm("d0"); \
  1065.   register struct TagItem * __AddRouteTagList_tags __asm("a0") = (_AddRouteTagList_tags); \
  1066.   __asm volatile ("jsr a6@(-414:W)" \
  1067.   : "=r"(__AddRouteTagList__re) \
  1068.   : "r"(__AddRouteTagList__bn), "r"(__AddRouteTagList_tags)  \
  1069.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1070.   __AddRouteTagList__re; \
  1071.   }); \
  1072.   _AddRouteTagList__re; \
  1073. })
  1074.  
  1075. #ifndef NO_INLINE_STDARG
  1076. static __inline__ LONG ___AddRouteTags(struct Library * SocketBase, ULONG tag, ...)
  1077. {
  1078.   return AddRouteTagList((struct TagItem *) &tag);
  1079. }
  1080.  
  1081. #define AddRouteTags(tags...) ___AddRouteTags(BSDSOCKET_BASE_NAME, tags)
  1082. #endif
  1083.  
  1084. #define DeleteRouteTagList(tags) ({ \
  1085.   struct TagItem * _DeleteRouteTagList_tags = (tags); \
  1086.   LONG _DeleteRouteTagList__re = \
  1087.   ({ \
  1088.   register struct Library * const __DeleteRouteTagList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1089.   register LONG __DeleteRouteTagList__re __asm("d0"); \
  1090.   register struct TagItem * __DeleteRouteTagList_tags __asm("a0") = (_DeleteRouteTagList_tags); \
  1091.   __asm volatile ("jsr a6@(-420:W)" \
  1092.   : "=r"(__DeleteRouteTagList__re) \
  1093.   : "r"(__DeleteRouteTagList__bn), "r"(__DeleteRouteTagList_tags)  \
  1094.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1095.   __DeleteRouteTagList__re; \
  1096.   }); \
  1097.   _DeleteRouteTagList__re; \
  1098. })
  1099.  
  1100. #ifndef NO_INLINE_STDARG
  1101. static __inline__ LONG ___DeleteRouteTags(struct Library * SocketBase, ULONG tag, ...)
  1102. {
  1103.   return DeleteRouteTagList((struct TagItem *) &tag);
  1104. }
  1105.  
  1106. #define DeleteRouteTags(tags...) ___DeleteRouteTags(BSDSOCKET_BASE_NAME, tags)
  1107. #endif
  1108.  
  1109. #define FreeRouteInfo(buf) ({ \
  1110.   struct rt_msghdr * _FreeRouteInfo_buf = (buf); \
  1111.   { \
  1112.   register struct Library * const __FreeRouteInfo__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1113.   register struct rt_msghdr * __FreeRouteInfo_buf __asm("a0") = (_FreeRouteInfo_buf); \
  1114.   __asm volatile ("jsr a6@(-432:W)" \
  1115.   : \
  1116.   : "r"(__FreeRouteInfo__bn), "r"(__FreeRouteInfo_buf)  \
  1117.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1118.   } \
  1119. })
  1120.  
  1121. #define GetRouteInfo(address_family, flags) ({ \
  1122.   LONG _GetRouteInfo_address_family = (address_family); \
  1123.   LONG _GetRouteInfo_flags = (flags); \
  1124.   struct rt_msghdr * _GetRouteInfo__re = \
  1125.   ({ \
  1126.   register struct Library * const __GetRouteInfo__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1127.   register struct rt_msghdr * __GetRouteInfo__re __asm("d0"); \
  1128.   register LONG __GetRouteInfo_address_family __asm("d0") = (_GetRouteInfo_address_family); \
  1129.   register LONG __GetRouteInfo_flags __asm("d1") = (_GetRouteInfo_flags); \
  1130.   __asm volatile ("jsr a6@(-438:W)" \
  1131.   : "=r"(__GetRouteInfo__re) \
  1132.   : "r"(__GetRouteInfo__bn), "r"(__GetRouteInfo_address_family), "r"(__GetRouteInfo_flags)  \
  1133.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1134.   __GetRouteInfo__re; \
  1135.   }); \
  1136.   _GetRouteInfo__re; \
  1137. })
  1138.  
  1139. #define AddInterfaceTagList(interface_name, device_name, unit, tags) ({ \
  1140.   STRPTR _AddInterfaceTagList_interface_name = (interface_name); \
  1141.   STRPTR _AddInterfaceTagList_device_name = (device_name); \
  1142.   LONG _AddInterfaceTagList_unit = (unit); \
  1143.   struct TagItem * _AddInterfaceTagList_tags = (tags); \
  1144.   LONG _AddInterfaceTagList__re = \
  1145.   ({ \
  1146.   register struct Library * const __AddInterfaceTagList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1147.   register LONG __AddInterfaceTagList__re __asm("d0"); \
  1148.   register STRPTR __AddInterfaceTagList_interface_name __asm("a0") = (_AddInterfaceTagList_interface_name); \
  1149.   register STRPTR __AddInterfaceTagList_device_name __asm("a1") = (_AddInterfaceTagList_device_name); \
  1150.   register LONG __AddInterfaceTagList_unit __asm("d0") = (_AddInterfaceTagList_unit); \
  1151.   register struct TagItem * __AddInterfaceTagList_tags __asm("a2") = (_AddInterfaceTagList_tags); \
  1152.   __asm volatile ("jsr a6@(-444:W)" \
  1153.   : "=r"(__AddInterfaceTagList__re) \
  1154.   : "r"(__AddInterfaceTagList__bn), "r"(__AddInterfaceTagList_interface_name), "r"(__AddInterfaceTagList_device_name), "r"(__AddInterfaceTagList_unit), "r"(__AddInterfaceTagList_tags)  \
  1155.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1156.   __AddInterfaceTagList__re; \
  1157.   }); \
  1158.   _AddInterfaceTagList__re; \
  1159. })
  1160.  
  1161. #ifndef NO_INLINE_STDARG
  1162. static __inline__ LONG ___AddInterfaceTags(struct Library * SocketBase, STRPTR interface_name, STRPTR device_name, LONG unit, ...)
  1163. {
  1164.   return AddInterfaceTagList(interface_name, device_name, unit, (struct TagItem *) ((ULONG) &unit + sizeof(LONG)));
  1165. }
  1166.  
  1167. #define AddInterfaceTags(interface_name, device_name, unit, tags...) ___AddInterfaceTags(BSDSOCKET_BASE_NAME, interface_name, device_name, unit, tags)
  1168. #endif
  1169.  
  1170. #define ConfigureInterfaceTagList(interface_name, tags) ({ \
  1171.   STRPTR _ConfigureInterfaceTagList_interface_name = (interface_name); \
  1172.   struct TagItem * _ConfigureInterfaceTagList_tags = (tags); \
  1173.   LONG _ConfigureInterfaceTagList__re = \
  1174.   ({ \
  1175.   register struct Library * const __ConfigureInterfaceTagList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1176.   register LONG __ConfigureInterfaceTagList__re __asm("d0"); \
  1177.   register STRPTR __ConfigureInterfaceTagList_interface_name __asm("a0") = (_ConfigureInterfaceTagList_interface_name); \
  1178.   register struct TagItem * __ConfigureInterfaceTagList_tags __asm("a1") = (_ConfigureInterfaceTagList_tags); \
  1179.   __asm volatile ("jsr a6@(-450:W)" \
  1180.   : "=r"(__ConfigureInterfaceTagList__re) \
  1181.   : "r"(__ConfigureInterfaceTagList__bn), "r"(__ConfigureInterfaceTagList_interface_name), "r"(__ConfigureInterfaceTagList_tags)  \
  1182.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1183.   __ConfigureInterfaceTagList__re; \
  1184.   }); \
  1185.   _ConfigureInterfaceTagList__re; \
  1186. })
  1187.  
  1188. #ifndef NO_INLINE_STDARG
  1189. static __inline__ LONG ___ConfigureInterfaceTags(struct Library * SocketBase, STRPTR interface_name, ...)
  1190. {
  1191.   return ConfigureInterfaceTagList(interface_name, (struct TagItem *) ((ULONG) &interface_name + sizeof(STRPTR)));
  1192. }
  1193.  
  1194. #define ConfigureInterfaceTags(interface_name, tags...) ___ConfigureInterfaceTags(BSDSOCKET_BASE_NAME, interface_name, tags)
  1195. #endif
  1196.  
  1197. #define ReleaseInterfaceList(list) ({ \
  1198.   struct List * _ReleaseInterfaceList_list = (list); \
  1199.   { \
  1200.   register struct Library * const __ReleaseInterfaceList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1201.   register struct List * __ReleaseInterfaceList_list __asm("a0") = (_ReleaseInterfaceList_list); \
  1202.   __asm volatile ("jsr a6@(-456:W)" \
  1203.   : \
  1204.   : "r"(__ReleaseInterfaceList__bn), "r"(__ReleaseInterfaceList_list)  \
  1205.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1206.   } \
  1207. })
  1208.  
  1209. #define ObtainInterfaceList() ({ \
  1210.   struct List * _ObtainInterfaceList__re = \
  1211.   ({ \
  1212.   register struct Library * const __ObtainInterfaceList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1213.   register struct List * __ObtainInterfaceList__re __asm("d0"); \
  1214.   __asm volatile ("jsr a6@(-462:W)" \
  1215.   : "=r"(__ObtainInterfaceList__re) \
  1216.   : "r"(__ObtainInterfaceList__bn)  \
  1217.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1218.   __ObtainInterfaceList__re; \
  1219.   }); \
  1220.   _ObtainInterfaceList__re; \
  1221. })
  1222.  
  1223. #define QueryInterfaceTagList(interface_name, tags) ({ \
  1224.   STRPTR _QueryInterfaceTagList_interface_name = (interface_name); \
  1225.   struct TagItem * _QueryInterfaceTagList_tags = (tags); \
  1226.   LONG _QueryInterfaceTagList__re = \
  1227.   ({ \
  1228.   register struct Library * const __QueryInterfaceTagList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1229.   register LONG __QueryInterfaceTagList__re __asm("d0"); \
  1230.   register STRPTR __QueryInterfaceTagList_interface_name __asm("a0") = (_QueryInterfaceTagList_interface_name); \
  1231.   register struct TagItem * __QueryInterfaceTagList_tags __asm("a1") = (_QueryInterfaceTagList_tags); \
  1232.   __asm volatile ("jsr a6@(-468:W)" \
  1233.   : "=r"(__QueryInterfaceTagList__re) \
  1234.   : "r"(__QueryInterfaceTagList__bn), "r"(__QueryInterfaceTagList_interface_name), "r"(__QueryInterfaceTagList_tags)  \
  1235.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1236.   __QueryInterfaceTagList__re; \
  1237.   }); \
  1238.   _QueryInterfaceTagList__re; \
  1239. })
  1240.  
  1241. #ifndef NO_INLINE_STDARG
  1242. static __inline__ LONG ___QueryInterfaceTags(struct Library * SocketBase, STRPTR interface_name, ...)
  1243. {
  1244.   return QueryInterfaceTagList(interface_name, (struct TagItem *) ((ULONG) &interface_name + sizeof(STRPTR)));
  1245. }
  1246.  
  1247. #define QueryInterfaceTags(interface_name, tags...) ___QueryInterfaceTags(BSDSOCKET_BASE_NAME, interface_name, tags)
  1248. #endif
  1249.  
  1250. #define CreateAddrAllocMessageA(version, protocol, interface_name, result_ptr, tags) ({ \
  1251.   LONG _CreateAddrAllocMessageA_version = (version); \
  1252.   LONG _CreateAddrAllocMessageA_protocol = (protocol); \
  1253.   STRPTR _CreateAddrAllocMessageA_interface_name = (interface_name); \
  1254.   struct AddressAllocationMessage ** _CreateAddrAllocMessageA_result_ptr = (result_ptr); \
  1255.   struct TagItem * _CreateAddrAllocMessageA_tags = (tags); \
  1256.   LONG _CreateAddrAllocMessageA__re = \
  1257.   ({ \
  1258.   register struct Library * const __CreateAddrAllocMessageA__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1259.   register LONG __CreateAddrAllocMessageA__re __asm("d0"); \
  1260.   register LONG __CreateAddrAllocMessageA_version __asm("d0") = (_CreateAddrAllocMessageA_version); \
  1261.   register LONG __CreateAddrAllocMessageA_protocol __asm("d1") = (_CreateAddrAllocMessageA_protocol); \
  1262.   register STRPTR __CreateAddrAllocMessageA_interface_name __asm("a0") = (_CreateAddrAllocMessageA_interface_name); \
  1263.   register struct AddressAllocationMessage ** __CreateAddrAllocMessageA_result_ptr __asm("a1") = (_CreateAddrAllocMessageA_result_ptr); \
  1264.   register struct TagItem * __CreateAddrAllocMessageA_tags __asm("a2") = (_CreateAddrAllocMessageA_tags); \
  1265.   __asm volatile ("jsr a6@(-474:W)" \
  1266.   : "=r"(__CreateAddrAllocMessageA__re) \
  1267.   : "r"(__CreateAddrAllocMessageA__bn), "r"(__CreateAddrAllocMessageA_version), "r"(__CreateAddrAllocMessageA_protocol), "r"(__CreateAddrAllocMessageA_interface_name), "r"(__CreateAddrAllocMessageA_result_ptr), "r"(__CreateAddrAllocMessageA_tags)  \
  1268.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1269.   __CreateAddrAllocMessageA__re; \
  1270.   }); \
  1271.   _CreateAddrAllocMessageA__re; \
  1272. })
  1273.  
  1274. #ifndef NO_INLINE_STDARG
  1275. static __inline__ LONG ___CreateAddrAllocMessage(struct Library * SocketBase, LONG version, LONG protocol, STRPTR interface_name, struct AddressAllocationMessage ** result_ptr, ...)
  1276. {
  1277.   return CreateAddrAllocMessageA(version, protocol, interface_name, result_ptr, (struct TagItem *) ((ULONG) &result_ptr + sizeof(struct AddressAllocationMessage **)));
  1278. }
  1279.  
  1280. #define CreateAddrAllocMessage(version, protocol, interface_name, result_ptr, tags...) ___CreateAddrAllocMessage(BSDSOCKET_BASE_NAME, version, protocol, interface_name, result_ptr, tags)
  1281. #endif
  1282.  
  1283. #define DeleteAddrAllocMessage(aam) ({ \
  1284.   struct AddressAllocationMessage * _DeleteAddrAllocMessage_aam = (aam); \
  1285.   { \
  1286.   register struct Library * const __DeleteAddrAllocMessage__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1287.   register struct AddressAllocationMessage * __DeleteAddrAllocMessage_aam __asm("a0") = (_DeleteAddrAllocMessage_aam); \
  1288.   __asm volatile ("jsr a6@(-480:W)" \
  1289.   : \
  1290.   : "r"(__DeleteAddrAllocMessage__bn), "r"(__DeleteAddrAllocMessage_aam)  \
  1291.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1292.   } \
  1293. })
  1294.  
  1295. #define BeginInterfaceConfig(message) ({ \
  1296.   struct AddressAllocationMessage * _BeginInterfaceConfig_message = (message); \
  1297.   { \
  1298.   register struct Library * const __BeginInterfaceConfig__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1299.   register struct AddressAllocationMessage * __BeginInterfaceConfig_message __asm("a0") = (_BeginInterfaceConfig_message); \
  1300.   __asm volatile ("jsr a6@(-486:W)" \
  1301.   : \
  1302.   : "r"(__BeginInterfaceConfig__bn), "r"(__BeginInterfaceConfig_message)  \
  1303.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1304.   } \
  1305. })
  1306.  
  1307. #define AbortInterfaceConfig(message) ({ \
  1308.   struct AddressAllocationMessage * _AbortInterfaceConfig_message = (message); \
  1309.   { \
  1310.   register struct Library * const __AbortInterfaceConfig__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1311.   register struct AddressAllocationMessage * __AbortInterfaceConfig_message __asm("a0") = (_AbortInterfaceConfig_message); \
  1312.   __asm volatile ("jsr a6@(-492:W)" \
  1313.   : \
  1314.   : "r"(__AbortInterfaceConfig__bn), "r"(__AbortInterfaceConfig_message)  \
  1315.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1316.   } \
  1317. })
  1318.  
  1319. #define AddNetMonitorHookTagList(type, hook, tags) ({ \
  1320.   LONG _AddNetMonitorHookTagList_type = (type); \
  1321.   struct Hook * _AddNetMonitorHookTagList_hook = (hook); \
  1322.   struct TagItem * _AddNetMonitorHookTagList_tags = (tags); \
  1323.   LONG _AddNetMonitorHookTagList__re = \
  1324.   ({ \
  1325.   register struct Library * const __AddNetMonitorHookTagList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1326.   register LONG __AddNetMonitorHookTagList__re __asm("d0"); \
  1327.   register LONG __AddNetMonitorHookTagList_type __asm("d0") = (_AddNetMonitorHookTagList_type); \
  1328.   register struct Hook * __AddNetMonitorHookTagList_hook __asm("a0") = (_AddNetMonitorHookTagList_hook); \
  1329.   register struct TagItem * __AddNetMonitorHookTagList_tags __asm("a1") = (_AddNetMonitorHookTagList_tags); \
  1330.   __asm volatile ("jsr a6@(-498:W)" \
  1331.   : "=r"(__AddNetMonitorHookTagList__re) \
  1332.   : "r"(__AddNetMonitorHookTagList__bn), "r"(__AddNetMonitorHookTagList_type), "r"(__AddNetMonitorHookTagList_hook), "r"(__AddNetMonitorHookTagList_tags)  \
  1333.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1334.   __AddNetMonitorHookTagList__re; \
  1335.   }); \
  1336.   _AddNetMonitorHookTagList__re; \
  1337. })
  1338.  
  1339. #ifndef NO_INLINE_STDARG
  1340. static __inline__ LONG ___AddNetMonitorHookTags(struct Library * SocketBase, LONG type, struct Hook * hook, ...)
  1341. {
  1342.   return AddNetMonitorHookTagList(type, hook, (struct TagItem *) ((ULONG) &hook + sizeof(struct Hook *)));
  1343. }
  1344.  
  1345. #define AddNetMonitorHookTags(type, hook, tags...) ___AddNetMonitorHookTags(BSDSOCKET_BASE_NAME, type, hook, tags)
  1346. #endif
  1347.  
  1348. #define RemoveNetMonitorHook(hook) ({ \
  1349.   struct Hook * _RemoveNetMonitorHook_hook = (hook); \
  1350.   { \
  1351.   register struct Library * const __RemoveNetMonitorHook__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1352.   register struct Hook * __RemoveNetMonitorHook_hook __asm("a0") = (_RemoveNetMonitorHook_hook); \
  1353.   __asm volatile ("jsr a6@(-504:W)" \
  1354.   : \
  1355.   : "r"(__RemoveNetMonitorHook__bn), "r"(__RemoveNetMonitorHook_hook)  \
  1356.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1357.   } \
  1358. })
  1359.  
  1360. #define GetNetworkStatistics(type, version, destination, size) ({ \
  1361.   LONG _GetNetworkStatistics_type = (type); \
  1362.   LONG _GetNetworkStatistics_version = (version); \
  1363.   APTR _GetNetworkStatistics_destination = (destination); \
  1364.   LONG _GetNetworkStatistics_size = (size); \
  1365.   LONG _GetNetworkStatistics__re = \
  1366.   ({ \
  1367.   register struct Library * const __GetNetworkStatistics__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1368.   register LONG __GetNetworkStatistics__re __asm("d0"); \
  1369.   register LONG __GetNetworkStatistics_type __asm("d0") = (_GetNetworkStatistics_type); \
  1370.   register LONG __GetNetworkStatistics_version __asm("d1") = (_GetNetworkStatistics_version); \
  1371.   register APTR __GetNetworkStatistics_destination __asm("a0") = (_GetNetworkStatistics_destination); \
  1372.   register LONG __GetNetworkStatistics_size __asm("d2") = (_GetNetworkStatistics_size); \
  1373.   __asm volatile ("jsr a6@(-510:W)" \
  1374.   : "=r"(__GetNetworkStatistics__re) \
  1375.   : "r"(__GetNetworkStatistics__bn), "r"(__GetNetworkStatistics_type), "r"(__GetNetworkStatistics_version), "r"(__GetNetworkStatistics_destination), "r"(__GetNetworkStatistics_size)  \
  1376.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1377.   __GetNetworkStatistics__re; \
  1378.   }); \
  1379.   _GetNetworkStatistics__re; \
  1380. })
  1381.  
  1382. #define AddDomainNameServer(address) ({ \
  1383.   STRPTR _AddDomainNameServer_address = (address); \
  1384.   LONG _AddDomainNameServer__re = \
  1385.   ({ \
  1386.   register struct Library * const __AddDomainNameServer__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1387.   register LONG __AddDomainNameServer__re __asm("d0"); \
  1388.   register STRPTR __AddDomainNameServer_address __asm("a0") = (_AddDomainNameServer_address); \
  1389.   __asm volatile ("jsr a6@(-516:W)" \
  1390.   : "=r"(__AddDomainNameServer__re) \
  1391.   : "r"(__AddDomainNameServer__bn), "r"(__AddDomainNameServer_address)  \
  1392.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1393.   __AddDomainNameServer__re; \
  1394.   }); \
  1395.   _AddDomainNameServer__re; \
  1396. })
  1397.  
  1398. #define RemoveDomainNameServer(address) ({ \
  1399.   STRPTR _RemoveDomainNameServer_address = (address); \
  1400.   LONG _RemoveDomainNameServer__re = \
  1401.   ({ \
  1402.   register struct Library * const __RemoveDomainNameServer__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1403.   register LONG __RemoveDomainNameServer__re __asm("d0"); \
  1404.   register STRPTR __RemoveDomainNameServer_address __asm("a0") = (_RemoveDomainNameServer_address); \
  1405.   __asm volatile ("jsr a6@(-522:W)" \
  1406.   : "=r"(__RemoveDomainNameServer__re) \
  1407.   : "r"(__RemoveDomainNameServer__bn), "r"(__RemoveDomainNameServer_address)  \
  1408.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1409.   __RemoveDomainNameServer__re; \
  1410.   }); \
  1411.   _RemoveDomainNameServer__re; \
  1412. })
  1413.  
  1414. #define ReleaseDomainNameServerList(list) ({ \
  1415.   struct List * _ReleaseDomainNameServerList_list = (list); \
  1416.   { \
  1417.   register struct Library * const __ReleaseDomainNameServerList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1418.   register struct List * __ReleaseDomainNameServerList_list __asm("a0") = (_ReleaseDomainNameServerList_list); \
  1419.   __asm volatile ("jsr a6@(-528:W)" \
  1420.   : \
  1421.   : "r"(__ReleaseDomainNameServerList__bn), "r"(__ReleaseDomainNameServerList_list)  \
  1422.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1423.   } \
  1424. })
  1425.  
  1426. #define ObtainDomainNameServerList() ({ \
  1427.   struct List * _ObtainDomainNameServerList__re = \
  1428.   ({ \
  1429.   register struct Library * const __ObtainDomainNameServerList__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1430.   register struct List * __ObtainDomainNameServerList__re __asm("d0"); \
  1431.   __asm volatile ("jsr a6@(-534:W)" \
  1432.   : "=r"(__ObtainDomainNameServerList__re) \
  1433.   : "r"(__ObtainDomainNameServerList__bn)  \
  1434.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1435.   __ObtainDomainNameServerList__re; \
  1436.   }); \
  1437.   _ObtainDomainNameServerList__re; \
  1438. })
  1439.  
  1440. #define setnetent(stay_open) ({ \
  1441.   LONG _setnetent_stay_open = (stay_open); \
  1442.   { \
  1443.   register struct Library * const __setnetent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1444.   register LONG __setnetent_stay_open __asm("d0") = (_setnetent_stay_open); \
  1445.   __asm volatile ("jsr a6@(-540:W)" \
  1446.   : \
  1447.   : "r"(__setnetent__bn), "r"(__setnetent_stay_open)  \
  1448.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1449.   } \
  1450. })
  1451.  
  1452. #define endnetent() ({ \
  1453.   register struct Library * const __endnetent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1454.   __asm volatile ("jsr a6@(-546:W)" \
  1455.   : \
  1456.   : "r"(__endnetent__bn)  \
  1457.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1458. })
  1459.  
  1460. #define getnetent() ({ \
  1461.   struct netent * _getnetent__re = \
  1462.   ({ \
  1463.   register struct Library * const __getnetent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1464.   register struct netent * __getnetent__re __asm("d0"); \
  1465.   __asm volatile ("jsr a6@(-552:W)" \
  1466.   : "=r"(__getnetent__re) \
  1467.   : "r"(__getnetent__bn)  \
  1468.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1469.   __getnetent__re; \
  1470.   }); \
  1471.   _getnetent__re; \
  1472. })
  1473.  
  1474. #define setprotoent(stay_open) ({ \
  1475.   LONG _setprotoent_stay_open = (stay_open); \
  1476.   { \
  1477.   register struct Library * const __setprotoent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1478.   register LONG __setprotoent_stay_open __asm("d0") = (_setprotoent_stay_open); \
  1479.   __asm volatile ("jsr a6@(-558:W)" \
  1480.   : \
  1481.   : "r"(__setprotoent__bn), "r"(__setprotoent_stay_open)  \
  1482.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1483.   } \
  1484. })
  1485.  
  1486. #define endprotoent() ({ \
  1487.   register struct Library * const __endprotoent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1488.   __asm volatile ("jsr a6@(-564:W)" \
  1489.   : \
  1490.   : "r"(__endprotoent__bn)  \
  1491.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1492. })
  1493.  
  1494. #define getprotoent() ({ \
  1495.   struct protoent * _getprotoent__re = \
  1496.   ({ \
  1497.   register struct Library * const __getprotoent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1498.   register struct protoent * __getprotoent__re __asm("d0"); \
  1499.   __asm volatile ("jsr a6@(-570:W)" \
  1500.   : "=r"(__getprotoent__re) \
  1501.   : "r"(__getprotoent__bn)  \
  1502.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1503.   __getprotoent__re; \
  1504.   }); \
  1505.   _getprotoent__re; \
  1506. })
  1507.  
  1508. #define setservent(stay_open) ({ \
  1509.   LONG _setservent_stay_open = (stay_open); \
  1510.   { \
  1511.   register struct Library * const __setservent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1512.   register LONG __setservent_stay_open __asm("d0") = (_setservent_stay_open); \
  1513.   __asm volatile ("jsr a6@(-576:W)" \
  1514.   : \
  1515.   : "r"(__setservent__bn), "r"(__setservent_stay_open)  \
  1516.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1517.   } \
  1518. })
  1519.  
  1520. #define endservent() ({ \
  1521.   register struct Library * const __endservent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1522.   __asm volatile ("jsr a6@(-582:W)" \
  1523.   : \
  1524.   : "r"(__endservent__bn)  \
  1525.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1526. })
  1527.  
  1528. #define getservent() ({ \
  1529.   struct servent * _getservent__re = \
  1530.   ({ \
  1531.   register struct Library * const __getservent__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1532.   register struct servent * __getservent__re __asm("d0"); \
  1533.   __asm volatile ("jsr a6@(-588:W)" \
  1534.   : "=r"(__getservent__re) \
  1535.   : "r"(__getservent__bn)  \
  1536.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1537.   __getservent__re; \
  1538.   }); \
  1539.   _getservent__re; \
  1540. })
  1541.  
  1542. #define inet_aton(cp, addr) ({ \
  1543.   STRPTR _inet_aton_cp = (cp); \
  1544.   struct in_addr * _inet_aton_addr = (addr); \
  1545.   LONG _inet_aton__re = \
  1546.   ({ \
  1547.   register struct Library * const __inet_aton__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1548.   register LONG __inet_aton__re __asm("d0"); \
  1549.   register STRPTR __inet_aton_cp __asm("a0") = (_inet_aton_cp); \
  1550.   register struct in_addr * __inet_aton_addr __asm("a1") = (_inet_aton_addr); \
  1551.   __asm volatile ("jsr a6@(-594:W)" \
  1552.   : "=r"(__inet_aton__re) \
  1553.   : "r"(__inet_aton__bn), "r"(__inet_aton_cp), "r"(__inet_aton_addr)  \
  1554.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1555.   __inet_aton__re; \
  1556.   }); \
  1557.   _inet_aton__re; \
  1558. })
  1559.  
  1560. #define inet_ntop(af, src, dst, size) ({ \
  1561.   LONG _inet_ntop_af = (af); \
  1562.   APTR _inet_ntop_src = (src); \
  1563.   STRPTR _inet_ntop_dst = (dst); \
  1564.   LONG _inet_ntop_size = (size); \
  1565.   STRPTR _inet_ntop__re = \
  1566.   ({ \
  1567.   register struct Library * const __inet_ntop__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1568.   register STRPTR __inet_ntop__re __asm("d0"); \
  1569.   register LONG __inet_ntop_af __asm("d0") = (_inet_ntop_af); \
  1570.   register APTR __inet_ntop_src __asm("a0") = (_inet_ntop_src); \
  1571.   register STRPTR __inet_ntop_dst __asm("a1") = (_inet_ntop_dst); \
  1572.   register LONG __inet_ntop_size __asm("d1") = (_inet_ntop_size); \
  1573.   __asm volatile ("jsr a6@(-600:W)" \
  1574.   : "=r"(__inet_ntop__re) \
  1575.   : "r"(__inet_ntop__bn), "r"(__inet_ntop_af), "r"(__inet_ntop_src), "r"(__inet_ntop_dst), "r"(__inet_ntop_size)  \
  1576.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1577.   __inet_ntop__re; \
  1578.   }); \
  1579.   _inet_ntop__re; \
  1580. })
  1581.  
  1582. #define inet_pton(af, src, dst) ({ \
  1583.   LONG _inet_pton_af = (af); \
  1584.   STRPTR _inet_pton_src = (src); \
  1585.   APTR _inet_pton_dst = (dst); \
  1586.   LONG _inet_pton__re = \
  1587.   ({ \
  1588.   register struct Library * const __inet_pton__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1589.   register LONG __inet_pton__re __asm("d0"); \
  1590.   register LONG __inet_pton_af __asm("d0") = (_inet_pton_af); \
  1591.   register STRPTR __inet_pton_src __asm("a0") = (_inet_pton_src); \
  1592.   register APTR __inet_pton_dst __asm("a1") = (_inet_pton_dst); \
  1593.   __asm volatile ("jsr a6@(-606:W)" \
  1594.   : "=r"(__inet_pton__re) \
  1595.   : "r"(__inet_pton__bn), "r"(__inet_pton_af), "r"(__inet_pton_src), "r"(__inet_pton_dst)  \
  1596.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1597.   __inet_pton__re; \
  1598.   }); \
  1599.   _inet_pton__re; \
  1600. })
  1601.  
  1602. #define In_LocalAddr(address) ({ \
  1603.   ULONG _In_LocalAddr_address = (address); \
  1604.   LONG _In_LocalAddr__re = \
  1605.   ({ \
  1606.   register struct Library * const __In_LocalAddr__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1607.   register LONG __In_LocalAddr__re __asm("d0"); \
  1608.   register ULONG __In_LocalAddr_address __asm("d0") = (_In_LocalAddr_address); \
  1609.   __asm volatile ("jsr a6@(-612:W)" \
  1610.   : "=r"(__In_LocalAddr__re) \
  1611.   : "r"(__In_LocalAddr__bn), "r"(__In_LocalAddr_address)  \
  1612.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1613.   __In_LocalAddr__re; \
  1614.   }); \
  1615.   _In_LocalAddr__re; \
  1616. })
  1617.  
  1618. #define In_CanForward(address) ({ \
  1619.   ULONG _In_CanForward_address = (address); \
  1620.   LONG _In_CanForward__re = \
  1621.   ({ \
  1622.   register struct Library * const __In_CanForward__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1623.   register LONG __In_CanForward__re __asm("d0"); \
  1624.   register ULONG __In_CanForward_address __asm("d0") = (_In_CanForward_address); \
  1625.   __asm volatile ("jsr a6@(-618:W)" \
  1626.   : "=r"(__In_CanForward__re) \
  1627.   : "r"(__In_CanForward__bn), "r"(__In_CanForward_address)  \
  1628.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1629.   __In_CanForward__re; \
  1630.   }); \
  1631.   _In_CanForward__re; \
  1632. })
  1633.  
  1634. #define mbuf_copym(m, off, len) ({ \
  1635.   struct mbuf * _mbuf_copym_m = (m); \
  1636.   LONG _mbuf_copym_off = (off); \
  1637.   LONG _mbuf_copym_len = (len); \
  1638.   struct mbuf * _mbuf_copym__re = \
  1639.   ({ \
  1640.   register struct Library * const __mbuf_copym__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1641.   register struct mbuf * __mbuf_copym__re __asm("d0"); \
  1642.   register struct mbuf * __mbuf_copym_m __asm("a0") = (_mbuf_copym_m); \
  1643.   register LONG __mbuf_copym_off __asm("d0") = (_mbuf_copym_off); \
  1644.   register LONG __mbuf_copym_len __asm("d1") = (_mbuf_copym_len); \
  1645.   __asm volatile ("jsr a6@(-624:W)" \
  1646.   : "=r"(__mbuf_copym__re) \
  1647.   : "r"(__mbuf_copym__bn), "r"(__mbuf_copym_m), "r"(__mbuf_copym_off), "r"(__mbuf_copym_len)  \
  1648.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1649.   __mbuf_copym__re; \
  1650.   }); \
  1651.   _mbuf_copym__re; \
  1652. })
  1653.  
  1654. #define mbuf_copyback(m, off, len, cp) ({ \
  1655.   struct mbuf * _mbuf_copyback_m = (m); \
  1656.   LONG _mbuf_copyback_off = (off); \
  1657.   LONG _mbuf_copyback_len = (len); \
  1658.   APTR _mbuf_copyback_cp = (cp); \
  1659.   LONG _mbuf_copyback__re = \
  1660.   ({ \
  1661.   register struct Library * const __mbuf_copyback__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1662.   register LONG __mbuf_copyback__re __asm("d0"); \
  1663.   register struct mbuf * __mbuf_copyback_m __asm("a0") = (_mbuf_copyback_m); \
  1664.   register LONG __mbuf_copyback_off __asm("d0") = (_mbuf_copyback_off); \
  1665.   register LONG __mbuf_copyback_len __asm("d1") = (_mbuf_copyback_len); \
  1666.   register APTR __mbuf_copyback_cp __asm("a1") = (_mbuf_copyback_cp); \
  1667.   __asm volatile ("jsr a6@(-630:W)" \
  1668.   : "=r"(__mbuf_copyback__re) \
  1669.   : "r"(__mbuf_copyback__bn), "r"(__mbuf_copyback_m), "r"(__mbuf_copyback_off), "r"(__mbuf_copyback_len), "r"(__mbuf_copyback_cp)  \
  1670.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1671.   __mbuf_copyback__re; \
  1672.   }); \
  1673.   _mbuf_copyback__re; \
  1674. })
  1675.  
  1676. #define mbuf_copydata(m, off, len, cp) ({ \
  1677.   struct mbuf * _mbuf_copydata_m = (m); \
  1678.   LONG _mbuf_copydata_off = (off); \
  1679.   LONG _mbuf_copydata_len = (len); \
  1680.   APTR _mbuf_copydata_cp = (cp); \
  1681.   LONG _mbuf_copydata__re = \
  1682.   ({ \
  1683.   register struct Library * const __mbuf_copydata__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1684.   register LONG __mbuf_copydata__re __asm("d0"); \
  1685.   register struct mbuf * __mbuf_copydata_m __asm("a0") = (_mbuf_copydata_m); \
  1686.   register LONG __mbuf_copydata_off __asm("d0") = (_mbuf_copydata_off); \
  1687.   register LONG __mbuf_copydata_len __asm("d1") = (_mbuf_copydata_len); \
  1688.   register APTR __mbuf_copydata_cp __asm("a1") = (_mbuf_copydata_cp); \
  1689.   __asm volatile ("jsr a6@(-636:W)" \
  1690.   : "=r"(__mbuf_copydata__re) \
  1691.   : "r"(__mbuf_copydata__bn), "r"(__mbuf_copydata_m), "r"(__mbuf_copydata_off), "r"(__mbuf_copydata_len), "r"(__mbuf_copydata_cp)  \
  1692.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1693.   __mbuf_copydata__re; \
  1694.   }); \
  1695.   _mbuf_copydata__re; \
  1696. })
  1697.  
  1698. #define mbuf_free(m) ({ \
  1699.   struct mbuf * _mbuf_free_m = (m); \
  1700.   struct mbuf * _mbuf_free__re = \
  1701.   ({ \
  1702.   register struct Library * const __mbuf_free__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1703.   register struct mbuf * __mbuf_free__re __asm("d0"); \
  1704.   register struct mbuf * __mbuf_free_m __asm("a0") = (_mbuf_free_m); \
  1705.   __asm volatile ("jsr a6@(-642:W)" \
  1706.   : "=r"(__mbuf_free__re) \
  1707.   : "r"(__mbuf_free__bn), "r"(__mbuf_free_m)  \
  1708.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1709.   __mbuf_free__re; \
  1710.   }); \
  1711.   _mbuf_free__re; \
  1712. })
  1713.  
  1714. #define mbuf_freem(m) ({ \
  1715.   struct mbuf * _mbuf_freem_m = (m); \
  1716.   { \
  1717.   register struct Library * const __mbuf_freem__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1718.   register struct mbuf * __mbuf_freem_m __asm("a0") = (_mbuf_freem_m); \
  1719.   __asm volatile ("jsr a6@(-648:W)" \
  1720.   : \
  1721.   : "r"(__mbuf_freem__bn), "r"(__mbuf_freem_m)  \
  1722.   : "d0", "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1723.   } \
  1724. })
  1725.  
  1726. #define mbuf_get() ({ \
  1727.   struct mbuf * _mbuf_get__re = \
  1728.   ({ \
  1729.   register struct Library * const __mbuf_get__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1730.   register struct mbuf * __mbuf_get__re __asm("d0"); \
  1731.   __asm volatile ("jsr a6@(-654:W)" \
  1732.   : "=r"(__mbuf_get__re) \
  1733.   : "r"(__mbuf_get__bn)  \
  1734.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1735.   __mbuf_get__re; \
  1736.   }); \
  1737.   _mbuf_get__re; \
  1738. })
  1739.  
  1740. #define mbuf_gethdr() ({ \
  1741.   struct mbuf * _mbuf_gethdr__re = \
  1742.   ({ \
  1743.   register struct Library * const __mbuf_gethdr__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1744.   register struct mbuf * __mbuf_gethdr__re __asm("d0"); \
  1745.   __asm volatile ("jsr a6@(-660:W)" \
  1746.   : "=r"(__mbuf_gethdr__re) \
  1747.   : "r"(__mbuf_gethdr__bn)  \
  1748.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1749.   __mbuf_gethdr__re; \
  1750.   }); \
  1751.   _mbuf_gethdr__re; \
  1752. })
  1753.  
  1754. #define mbuf_prepend(m, len) ({ \
  1755.   struct mbuf * _mbuf_prepend_m = (m); \
  1756.   LONG _mbuf_prepend_len = (len); \
  1757.   struct mbuf * _mbuf_prepend__re = \
  1758.   ({ \
  1759.   register struct Library * const __mbuf_prepend__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1760.   register struct mbuf * __mbuf_prepend__re __asm("d0"); \
  1761.   register struct mbuf * __mbuf_prepend_m __asm("a0") = (_mbuf_prepend_m); \
  1762.   register LONG __mbuf_prepend_len __asm("d0") = (_mbuf_prepend_len); \
  1763.   __asm volatile ("jsr a6@(-666:W)" \
  1764.   : "=r"(__mbuf_prepend__re) \
  1765.   : "r"(__mbuf_prepend__bn), "r"(__mbuf_prepend_m), "r"(__mbuf_prepend_len)  \
  1766.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1767.   __mbuf_prepend__re; \
  1768.   }); \
  1769.   _mbuf_prepend__re; \
  1770. })
  1771.  
  1772. #define mbuf_cat(m, n) ({ \
  1773.   struct mbuf * _mbuf_cat_m = (m); \
  1774.   struct mbuf * _mbuf_cat_n = (n); \
  1775.   LONG _mbuf_cat__re = \
  1776.   ({ \
  1777.   register struct Library * const __mbuf_cat__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1778.   register LONG __mbuf_cat__re __asm("d0"); \
  1779.   register struct mbuf * __mbuf_cat_m __asm("a0") = (_mbuf_cat_m); \
  1780.   register struct mbuf * __mbuf_cat_n __asm("a1") = (_mbuf_cat_n); \
  1781.   __asm volatile ("jsr a6@(-672:W)" \
  1782.   : "=r"(__mbuf_cat__re) \
  1783.   : "r"(__mbuf_cat__bn), "r"(__mbuf_cat_m), "r"(__mbuf_cat_n)  \
  1784.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1785.   __mbuf_cat__re; \
  1786.   }); \
  1787.   _mbuf_cat__re; \
  1788. })
  1789.  
  1790. #define mbuf_adj(mp, req_len) ({ \
  1791.   struct mbuf * _mbuf_adj_mp = (mp); \
  1792.   LONG _mbuf_adj_req_len = (req_len); \
  1793.   LONG _mbuf_adj__re = \
  1794.   ({ \
  1795.   register struct Library * const __mbuf_adj__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1796.   register LONG __mbuf_adj__re __asm("d0"); \
  1797.   register struct mbuf * __mbuf_adj_mp __asm("a0") = (_mbuf_adj_mp); \
  1798.   register LONG __mbuf_adj_req_len __asm("d0") = (_mbuf_adj_req_len); \
  1799.   __asm volatile ("jsr a6@(-678:W)" \
  1800.   : "=r"(__mbuf_adj__re) \
  1801.   : "r"(__mbuf_adj__bn), "r"(__mbuf_adj_mp), "r"(__mbuf_adj_req_len)  \
  1802.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1803.   __mbuf_adj__re; \
  1804.   }); \
  1805.   _mbuf_adj__re; \
  1806. })
  1807.  
  1808. #define mbuf_pullup(m, len) ({ \
  1809.   struct mbuf * _mbuf_pullup_m = (m); \
  1810.   LONG _mbuf_pullup_len = (len); \
  1811.   struct mbuf * _mbuf_pullup__re = \
  1812.   ({ \
  1813.   register struct Library * const __mbuf_pullup__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1814.   register struct mbuf * __mbuf_pullup__re __asm("d0"); \
  1815.   register struct mbuf * __mbuf_pullup_m __asm("a0") = (_mbuf_pullup_m); \
  1816.   register LONG __mbuf_pullup_len __asm("d0") = (_mbuf_pullup_len); \
  1817.   __asm volatile ("jsr a6@(-684:W)" \
  1818.   : "=r"(__mbuf_pullup__re) \
  1819.   : "r"(__mbuf_pullup__bn), "r"(__mbuf_pullup_m), "r"(__mbuf_pullup_len)  \
  1820.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1821.   __mbuf_pullup__re; \
  1822.   }); \
  1823.   _mbuf_pullup__re; \
  1824. })
  1825.  
  1826. #define ProcessIsServer(pr) ({ \
  1827.   struct Process * _ProcessIsServer_pr = (pr); \
  1828.   BOOL _ProcessIsServer__re = \
  1829.   ({ \
  1830.   register struct Library * const __ProcessIsServer__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1831.   register BOOL __ProcessIsServer__re __asm("d0"); \
  1832.   register struct Process * __ProcessIsServer_pr __asm("a0") = (_ProcessIsServer_pr); \
  1833.   __asm volatile ("jsr a6@(-690:W)" \
  1834.   : "=r"(__ProcessIsServer__re) \
  1835.   : "r"(__ProcessIsServer__bn), "r"(__ProcessIsServer_pr)  \
  1836.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1837.   __ProcessIsServer__re; \
  1838.   }); \
  1839.   _ProcessIsServer__re; \
  1840. })
  1841.  
  1842. #define ObtainServerSocket() ({ \
  1843.   LONG _ObtainServerSocket__re = \
  1844.   ({ \
  1845.   register struct Library * const __ObtainServerSocket__bn __asm("a6") = (struct Library *) (BSDSOCKET_BASE_NAME);\
  1846.   register LONG __ObtainServerSocket__re __asm("d0"); \
  1847.   __asm volatile ("jsr a6@(-696:W)" \
  1848.   : "=r"(__ObtainServerSocket__re) \
  1849.   : "r"(__ObtainServerSocket__bn)  \
  1850.   : "d1", "a0", "a1", "fp0", "fp1", "cc", "memory"); \
  1851.   __ObtainServerSocket__re; \
  1852.   }); \
  1853.   _ObtainServerSocket__re; \
  1854. })
  1855.  
  1856. #endif /*  _INLINE_BSDSOCKET_H  */
  1857.